home *** CD-ROM | disk | FTP | other *** search
/ Aminet 4 / Aminet 4 - November 1994.iso / aminet / comm / term / term41source.lha / Extras / Source / term-Source.lha / SerialIO.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-31  |  10.8 KB  |  679 lines
  1. /*
  2. **    SerialIO.c
  3. **
  4. **    Serial read/write routines
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. STATIC LONG __aligned    ReadQueued    = FALSE,
  13.             WriteQueued    = FALSE;
  14.  
  15.     /* DeleteLED():
  16.      *
  17.      *    Dummy routine, the real implementation may
  18.      *    follow in a later release.
  19.      */
  20.  
  21. VOID
  22. DeleteLED()
  23. {
  24. }
  25.  
  26.     /* CreateLED():
  27.      *
  28.      *    Dummy routine, the real implementation may
  29.      *    follow in a later release.
  30.      */
  31.  
  32. VOID
  33. CreateLED()
  34. {
  35. }
  36.  
  37.     /* ResetSerialRead():
  38.      *
  39.      *    Reset the read status.
  40.      */
  41.  
  42. VOID
  43. ResetSerialRead()
  44. {
  45.     ReadQueued = FALSE;
  46. }
  47.  
  48.     /* CheckSerialRead():
  49.      *
  50.      *    Check if a read request is finished.
  51.      */
  52.  
  53. BOOLEAN
  54. CheckSerialRead()
  55. {
  56.     if(ReadRequest && ReadQueued)
  57.     {
  58.         if(CheckIO(ReadRequest))
  59.             return(TRUE);
  60.     }
  61.  
  62.     return(FALSE);
  63. }
  64.  
  65.     /* WaitSerialRead():
  66.      *
  67.      *    Wait for the read request to terminate.
  68.      */
  69.  
  70. BYTE
  71. WaitSerialRead()
  72. {
  73.     if(ReadRequest && ReadQueued)
  74.     {
  75.         ReadQueued = FALSE;
  76.  
  77.         return(WaitIO(ReadRequest));
  78.     }
  79.     else
  80.         return(0);
  81. }
  82.  
  83.     /* StopSerialRead():
  84.      *
  85.      *    Force a read request to terminate.
  86.      */
  87.  
  88. VOID
  89. StopSerialRead()
  90. {
  91.     if(ReadRequest && ReadQueued)
  92.     {
  93.         if(!CheckIO(ReadRequest))
  94.             AbortIO(ReadRequest);
  95.  
  96.         WaitIO(ReadRequest);
  97.  
  98.         ReadQueued = FALSE;
  99.     }
  100. }
  101.  
  102.     /* StartSerialRead(register ULONG Length,register APTR Data):
  103.      *
  104.      *    Start a serial read request asynchronously.
  105.      */
  106.  
  107. VOID __regargs
  108. StartSerialRead(register APTR Data,register ULONG Length)
  109. {
  110.     if(ReadRequest)
  111.     {
  112.         if(ReadQueued)
  113.             StopSerialRead();
  114.  
  115.         ReadRequest -> IOSer . io_Command    = CMD_READ;
  116.         ReadRequest -> IOSer . io_Length    = Length;
  117.         ReadRequest -> IOSer . io_Data        = Data;
  118.  
  119.         ClrSignal(1L << ReadPort -> mp_SigBit);
  120.  
  121.         SendIO(ReadRequest);
  122.  
  123.         ReadQueued = TRUE;
  124.     }
  125. }
  126.  
  127.     /* DoSerialRead(register ULONG Length,register APTR Data):
  128.      *
  129.      *    Perform a read request synchronously.
  130.      */
  131.  
  132. BYTE __regargs
  133. DoSerialRead(register APTR Data,register ULONG Length)
  134. {
  135.     if(ReadRequest)
  136.     {
  137.         if(ReadQueued)
  138.             StopSerialRead();
  139.  
  140.         ReadRequest -> IOSer . io_Command    = CMD_READ;
  141.         ReadRequest -> IOSer . io_Length    = Length;
  142.         ReadRequest -> IOSer . io_Data        = Data;
  143.  
  144.         return(DoIO(ReadRequest));
  145.     }
  146.     else
  147.         return(IOERR_SELFTEST);
  148. }
  149.  
  150.     /* ResetSerialWrite():
  151.      *
  152.      *    Reset the write status.
  153.      */
  154.  
  155. VOID
  156. ResetSerialWrite()
  157. {
  158.     WriteQueued = FALSE;
  159. }
  160.  
  161.     /* CheckSerialWrite():
  162.      *
  163.      *    Check if a write request is finished.
  164.      */
  165.  
  166. BOOLEAN
  167. CheckSerialWrite()
  168. {
  169.     if(WriteRequest && WriteQueued)
  170.     {
  171.         if(!CheckIO(WriteRequest))
  172.             return(TRUE);
  173.     }
  174.  
  175.     return(FALSE);
  176. }
  177.  
  178.     /* WaitSerialWrite():
  179.      *
  180.      *    Wait for the write request to terminate.
  181.      */
  182.  
  183. BYTE
  184. WaitSerialWrite()
  185. {
  186.     if(WriteRequest && WriteQueued)
  187.     {
  188.         WriteQueued = FALSE;
  189.  
  190.         return(WaitIO(WriteRequest));
  191.     }
  192.     else
  193.         return(0);
  194. }
  195.  
  196.     /* StopSerialWrite():
  197.      *
  198.      *    Force a write request to terminate.
  199.      */
  200.  
  201. VOID
  202. StopSerialWrite()
  203. {
  204.     if(WriteRequest && WriteQueued)
  205.     {
  206.         if(!CheckIO(WriteRequest))
  207.             AbortIO(WriteRequest);
  208.  
  209.         WaitIO(WriteRequest);
  210.  
  211.         WriteQueued = FALSE;
  212.     }
  213. }
  214.  
  215.     /* StartSerialWrite(register ULONG Length,register APTR Data):
  216.      *
  217.      *    Start a serial write request asynchronously.
  218.      */
  219.  
  220. VOID __regargs
  221. StartSerialWrite(register APTR Data,register ULONG Length)
  222. {
  223.     if(WriteRequest)
  224.     {
  225.         if(WriteQueued)
  226.             StopSerialWrite();
  227.  
  228.         WriteRequest -> IOSer . io_Command    = CMD_WRITE;
  229.         WriteRequest -> IOSer . io_Length    = Length;
  230.         WriteRequest -> IOSer . io_Data        = Data;
  231.  
  232.         ClrSignal(1L << WriteRequest -> IOSer . io_Message . mn_ReplyPort -> mp_SigBit);
  233.  
  234.         SendIO(WriteRequest);
  235.  
  236.         WriteQueued = TRUE;
  237.     }
  238. }
  239.  
  240.     /* DoSerialWrite(register ULONG Length,register APTR Data):
  241.      *
  242.      *    Perform a write request synchronously.
  243.      */
  244.  
  245. BYTE __regargs
  246. DoSerialWrite(register APTR Data,register ULONG Length)
  247. {
  248.     if(WriteRequest)
  249.     {
  250.         if(WriteQueued)
  251.             StopSerialWrite();
  252.  
  253.         WriteRequest -> IOSer . io_Command    = CMD_WRITE;
  254.         WriteRequest -> IOSer . io_Length    = Length;
  255.         WriteRequest -> IOSer . io_Data        = Data;
  256.  
  257.         return(DoIO(WriteRequest));
  258.     }
  259.     else
  260.         return(IOERR_SELFTEST);
  261. }
  262.  
  263.     /* DoSerialCmd(register UWORD Command):
  264.      *
  265.      *    Perform single command.
  266.      */
  267.  
  268. BYTE __regargs
  269. DoSerialCmd(register UWORD Command)
  270. {
  271.     if(WriteRequest)
  272.     {
  273.         if(WriteQueued)
  274.             StopSerialWrite();
  275.  
  276.         WriteRequest -> IOSer . io_Command = Command;
  277.  
  278.         return(DoIO(WriteRequest));
  279.     }
  280.     else
  281.         return(IOERR_SELFTEST);
  282. }
  283.  
  284.     /* GetSerialWaiting():
  285.      *
  286.      *    Query the number of bytes still waiting to be read
  287.      *    from the serial port.
  288.      */
  289.  
  290. ULONG
  291. GetSerialWaiting()
  292. {
  293.     if(WriteRequest)
  294.     {
  295.         if(WriteQueued)
  296.             StopSerialWrite();
  297.  
  298.         WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  299.  
  300.         DoIO(WriteRequest);
  301.  
  302.         return(WriteRequest -> IOSer . io_Actual);
  303.     }
  304.     else
  305.         return(0);
  306. }
  307.  
  308.     /* GetSerialStatus():
  309.      *
  310.      *    Query the current serial port status.
  311.      */
  312.  
  313. UWORD
  314. GetSerialStatus()
  315. {
  316.     if(WriteRequest)
  317.     {
  318.         if(WriteQueued)
  319.             StopSerialWrite();
  320.  
  321.         WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  322.  
  323.         DoIO(WriteRequest);
  324.  
  325.         return(WriteRequest -> io_Status);
  326.     }
  327.     else
  328.         return(CIAF_COMCD | CIAF_COMDSR);
  329. }
  330.  
  331.     /* GetSerialInfo(register ULONG *Waiting,register UWORD *Status):
  332.      *
  333.      *    Query both the number of bytes waiting to be read and
  334.      *    the current serial status.
  335.      */
  336.  
  337. VOID __regargs
  338. GetSerialInfo(register ULONG *Waiting,register UWORD *Status)
  339. {
  340.     if(WriteRequest)
  341.     {
  342.         if(WriteQueued)
  343.             StopSerialWrite();
  344.  
  345.         WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  346.  
  347.         DoIO(WriteRequest);
  348.  
  349.         *Waiting    = WriteRequest -> IOSer . io_Actual;
  350.         *Status        = WriteRequest -> io_Status;
  351.     }
  352.     else
  353.     {
  354.         *Waiting    = 0;
  355.         *Status        = CIAF_COMCD | CIAF_COMDSR;
  356.     }
  357. }
  358.  
  359.     /* SetSerialAttributes():
  360.      *
  361.      *    Set the serial driver attributes.
  362.      */
  363.  
  364. STATIC VOID
  365. SetSerialAttributes(struct IOExtSer *Request,struct TagItem *Tags)
  366. {
  367.     struct TagItem *Tag;
  368.  
  369.     while(Tag = NextTagItem(&Tags))
  370.     {
  371.         switch(Tag -> ti_Tag)
  372.         {
  373.             case SERA_Baud:
  374.  
  375.                 Request -> io_Baud = Tag -> ti_Data;
  376.                 break;
  377.  
  378.             case SERA_BreakTime:
  379.  
  380.                 Request -> io_BrkTime = Tag -> ti_Data;
  381.                 break;
  382.  
  383.             case SERA_BitsPerChar:
  384.  
  385.                 Request -> io_ReadLen    = Tag -> ti_Data;
  386.                 Request -> io_WriteLen    = Tag -> ti_Data;
  387.                 break;
  388.  
  389.             case SERA_StopBits:
  390.  
  391.                 Request -> io_StopBits = Tag -> ti_Data;
  392.                 break;
  393.  
  394.             case SERA_BufferSize:
  395.  
  396.                 Request -> io_RBufLen = Tag -> ti_Data;
  397.                 break;
  398.  
  399.             case SERA_Parity:
  400.  
  401.                 Request -> io_ExtFlags &= ~(SEXTF_MSPON | SEXTF_MARK);
  402.                 Request -> io_SerFlags &= ~(SERF_PARTY_ON | SERF_PARTY_ODD);
  403.  
  404.                 switch(Tag -> ti_Data)
  405.                 {
  406.                     case PARITY_EVEN:
  407.  
  408.                         Request -> io_SerFlags |= SERF_PARTY_ON;
  409.                         break;
  410.  
  411.                     case PARITY_ODD:
  412.  
  413.                         Request -> io_SerFlags |= SERF_PARTY_ON | SERF_PARTY_ODD;
  414.                         break;
  415.  
  416.                     case PARITY_MARK:
  417.  
  418.                         Request -> io_SerFlags |= SERF_PARTY_ON;
  419.                         Request -> io_ExtFlags |= SEXTF_MSPON | SEXTF_MARK;
  420.                         break;
  421.  
  422.                     case PARITY_SPACE:
  423.  
  424.                         Request -> io_SerFlags |= SERF_PARTY_ON;
  425.                         Request -> io_ExtFlags |= SEXTF_MSPON;
  426.                         break;
  427.                 }
  428.  
  429.                 break;
  430.  
  431.             case SERA_Handshaking:
  432.  
  433.                 if(Tag -> ti_Data == HANDSHAKING_NONE)
  434.                     Request -> io_SerFlags &= ~SERF_7WIRE;
  435.                 else
  436.                     Request -> io_SerFlags |=  SERF_7WIRE;
  437.  
  438.                 break;
  439.  
  440.             case SERA_HighSpeed:
  441.  
  442.                 if(Tag -> ti_Data)
  443.                     Request -> io_SerFlags |=  SERF_RAD_BOOGIE;
  444.                 else
  445.                     Request -> io_SerFlags &= ~SERF_RAD_BOOGIE;
  446.  
  447.                 break;
  448.  
  449.             case SERA_Shared:
  450.  
  451.                 if(Tag -> ti_Data)
  452.                     Request -> io_SerFlags |=  SERF_SHARED;
  453.                 else
  454.                     Request -> io_SerFlags &= ~SERF_SHARED;
  455.  
  456.                 break;
  457.         }
  458.     }
  459.  
  460.     Request -> io_SerFlags |= SERF_XDISABLED;
  461. }
  462.  
  463.     /* GetSerialAttributes():
  464.      *
  465.      *    Get the serial driver attributes.
  466.      */
  467.  
  468. STATIC ULONG
  469. GetSerialAttributes(struct IOExtSer *Request,struct TagItem *Tags)
  470. {
  471.     struct TagItem    *Tag;
  472.     ULONG        *Data,
  473.              Result = NULL;
  474.  
  475.     while(Tag = NextTagItem(&Tags))
  476.     {
  477.         if(!(Data = (ULONG *)Tag -> ti_Data))
  478.             Data = &Result;
  479.  
  480.         switch(Tag -> ti_Tag)
  481.         {
  482.             case SERA_Baud:
  483.  
  484.                 *Data = Request -> io_Baud;
  485.                 break;
  486.  
  487.             case SERA_BreakTime:
  488.  
  489.                 *Data = Request -> io_BrkTime;
  490.                 break;
  491.  
  492.             case SERA_BitsPerChar:
  493.  
  494.                 *Data = Request -> io_ReadLen;
  495.                 break;
  496.  
  497.             case SERA_StopBits:
  498.  
  499.                 *Data = Request -> io_StopBits;
  500.                 break;
  501.  
  502.             case SERA_BufferSize:
  503.  
  504.                 *Data = Request -> io_RBufLen;
  505.                 break;
  506.  
  507.             case SERA_Parity:
  508.  
  509.                 Request -> io_ExtFlags &= ~(SEXTF_MSPON | SEXTF_MARK);
  510.                 Request -> io_SerFlags &= ~(SERF_PARTY_ON | SERF_PARTY_ODD);
  511.  
  512.                 switch(Tag -> ti_Data)
  513.                 {
  514.                     case PARITY_EVEN:
  515.  
  516.                         Request -> io_SerFlags |= SERF_PARTY_ON;
  517.                         break;
  518.  
  519.                     case PARITY_ODD:
  520.  
  521.                         Request -> io_SerFlags |= SERF_PARTY_ON | SERF_PARTY_ODD;
  522.                         break;
  523.  
  524.                     case PARITY_MARK:
  525.  
  526.                         Request -> io_SerFlags |= SERF_PARTY_ON;
  527.                         Request -> io_ExtFlags |= SEXTF_MSPON | SEXTF_MARK;
  528.                         break;
  529.  
  530.                     case PARITY_SPACE:
  531.  
  532.                         Request -> io_SerFlags |= SERF_PARTY_ON;
  533.                         Request -> io_ExtFlags |= SEXTF_MSPON;
  534.                         break;
  535.                 }
  536.  
  537.                 switch(Request -> io_ExtFlags & (SEXTF_MSPON | SEXTF_MARK))
  538.                 {
  539.                     case SEXTF_MSPON | SEXTF_MARK:
  540.  
  541.                         *Data = PARITY_MARK;
  542.                         break;
  543.  
  544.                     case SEXTF_MSPON:
  545.  
  546.                         *Data = PARITY_SPACE;
  547.                         break;
  548.  
  549.                     default:
  550.  
  551.                         switch(Request -> io_SerFlags & (SERF_PARTY_ON | SERF_PARTY_ODD))
  552.                         {
  553.                             case SERF_PARTY_ON | SERF_PARTY_ODD:
  554.  
  555.                                 *Data = PARITY_ODD;
  556.                                 break;
  557.  
  558.                             case SERF_PARTY_ON:
  559.  
  560.                                 *Data = PARITY_EVEN;
  561.                                 break;
  562.  
  563.                             default:
  564.  
  565.                                 *Data = PARITY_NONE;
  566.                                 break;
  567.                         }
  568.  
  569.                         break;
  570.                 }
  571.  
  572.                 break;
  573.  
  574.             case SERA_Handshaking:
  575.  
  576.                 if(Request -> io_SerFlags & SERF_7WIRE)
  577.                     *Data = TRUE;
  578.                 else
  579.                     *Data = FALSE;
  580.  
  581.                 break;
  582.  
  583.             case SERA_HighSpeed:
  584.  
  585.                 if(Request -> io_SerFlags & SERF_RAD_BOOGIE)
  586.                     *Data = TRUE;
  587.                 else
  588.                     *Data = FALSE;
  589.  
  590.                 break;
  591.  
  592.             case SERA_Shared:
  593.  
  594.                 if(Request -> io_SerFlags & SERF_SHARED)
  595.                     *Data = TRUE;
  596.                 else
  597.                     *Data = FALSE;
  598.  
  599.                 break;
  600.         }
  601.     }
  602.  
  603.     return(Result);
  604. }
  605.  
  606.     /* SetSerialReadAttributes():
  607.      *
  608.      *    Set the serial read driver parameters.
  609.      */
  610.  
  611. BYTE __stdargs
  612. SetSerialReadAttributes(Tag FirstTag,...)
  613. {
  614.     if(ReadRequest)
  615.     {
  616.         if(ReadQueued)
  617.             StopSerialRead();
  618.  
  619.         SetSerialAttributes(ReadRequest,(struct TagItem *)&FirstTag);
  620.  
  621.         ReadRequest -> IOSer . io_Command = SDCMD_SETPARAMS;
  622.  
  623.         return(DoIO(ReadRequest));
  624.     }
  625.     else
  626.         return(IOERR_SELFTEST);
  627. }
  628.  
  629.     /* SetSerialWriteAttributes():
  630.      *
  631.      *    Set the serial write driver parameters.
  632.      */
  633.  
  634. BYTE __stdargs
  635. SetSerialWriteAttributes(Tag FirstTag,...)
  636. {
  637.     if(WriteRequest)
  638.     {
  639.         if(WriteQueued)
  640.             StopSerialWrite();
  641.  
  642.         SetSerialAttributes(WriteRequest,(struct TagItem *)&FirstTag);
  643.  
  644.         WriteRequest -> IOSer . io_Command = SDCMD_SETPARAMS;
  645.  
  646.         return(DoIO(WriteRequest));
  647.     }
  648.     else
  649.         return(IOERR_SELFTEST);
  650. }
  651.  
  652.     /* GetSerialReadAttributes():
  653.      *
  654.      *    Get the serial read driver parameters.
  655.      */
  656.  
  657. ULONG __stdargs
  658. GetSerialReadAttributes(Tag FirstTag,...)
  659. {
  660.     if(ReadRequest)
  661.         return(GetSerialAttributes(ReadRequest,(struct TagItem *)&FirstTag));
  662.     else
  663.         return(NULL);
  664. }
  665.  
  666.     /* GetSerialWriteAttributes():
  667.      *
  668.      *    Get the serial write driver parameters.
  669.      */
  670.  
  671. ULONG __stdargs
  672. GetSerialWriteAttributes(Tag FirstTag,...)
  673. {
  674.     if(WriteRequest)
  675.         return(GetSerialAttributes(WriteRequest,(struct TagItem *)&FirstTag));
  676.     else
  677.         return(NULL);
  678. }
  679.